home *** CD-ROM | disk | FTP | other *** search
/ Light ROM 1 / LIGHT-ROM 1 (Amiga Library Services)(1994).iso / ffdisks / d913.lha / PickStartup / pickstartup.c < prev    next >
C/C++ Source or Header  |  1993-10-03  |  17KB  |  535 lines
  1.  
  2. /*  INCLUDES for Intuition  ******************************************** */
  3. ///
  4. #include "exec/types.h"
  5. #include "exec/libraries.h"
  6. #include "exec/memory.h"
  7. #include "libraries/asl.h"
  8. #include "proto/exec.h"
  9.  
  10. #include "clib/intuition_protos.h"
  11. #include "clib/dos_protos.h"
  12. #include "clib/exec_protos.h"
  13. #include "clib/asl_protos.h"
  14. #include "clib/alib_protos.h"
  15.  
  16. #include "devices/keyboard.h"
  17. #include "stdio.h"
  18. #include "string.h"
  19. #include "stdlib.h"
  20. #include "dos/dos.h"
  21. #include "intuition/intuition.h"
  22. #include "intuition/intuitionbase.h"
  23. #include "intuition/screens.h"
  24.  
  25.  
  26. UBYTE *vers = "$VER: PickStartup V1.3";
  27. ///
  28. /* Window defines */
  29. ///
  30. #define MY_WIN_LEFT   0
  31. #define MY_WIN_TOP    0
  32. #define MY_WIN_WIDTH  356
  33. #define MY_WIN_HEIGHT 69
  34. #define MAXPATH    512         /*  path/file buffer max size  */
  35. #define MATRIX_SIZE 16L         /* 2.04 Keyboard Matrix Size */
  36.  
  37. ///
  38. /*************************************************************************
  39. *                        Var Stuff                                       *
  40. *************************************************************************/
  41. ///
  42. struct EasyStruct MyHelp =
  43. { 
  44.       sizeof(struct EasyStruct),
  45.       0,
  46.       "CommanLine Options are:",
  47.       "PickStartup2 [?] [RMB=] [DIR=] [FILTER=] [DELAY=] [KEY=] [F1=] [NOWIN]\n\n"
  48.       "DeFaults are:\n"
  49.       "? NONE unless you ask.\n"
  50.       "KEY=0x63 or commonly known as the Ctrl key.\n"
  51.       "RMB=none\n"
  52.       "F1=none\n"
  53.       "DIR=S:special-startups\n"
  54.       "DELAY=5\n"
  55.       "FILTER=Start-#?\n"
  56.       "NOWIN\n"
  57.       "Example....... \n"
  58.       "Pickstartup RMB=S:test F1=S:Test2 DELAY=7 DIR=S: FILTER=s#?\n"
  59.       "This will execute the s:test if you press the RMB or s:test2 if F1 pressed\n"
  60.       "Or open ASL Req to Dir s: and display all filenames starting with s.\n"
  61.       "If no button pressed the window will remain open for a delay of 7\n"
  62.       "unless NOWIN option used. Then close and continue with your \n"
  63.       "current Startup-sequence.\n"
  64.       "This DELAY time will vary depending on your system\n" ,
  65.       "Thanks|Show some KeyCodes",
  66. };
  67.  
  68. struct EasyStruct SomeKeyCodesHelp =
  69. { 
  70.       sizeof(struct EasyStruct),
  71.       0,
  72.       " Here are some common KeyCodes ",
  73.       "63  CTRL Key  (default) \n"
  74.       "60  Left Shift Key \n"
  75.       "64  Left Alt Key \n"
  76.       "61  Right Shift Key \n"
  77.       "65  Right Alt Key  \n"
  78.       "50-59  F1-F10\n"
  79.       "Don't use 50 if you are using the F1= option\n",
  80.       "Thanks",
  81. };
  82.  
  83. struct IntuiText IText1 =
  84. {
  85.   1, 0, JAM2,                   /* front and back text pens, drawmode and fill byte */
  86.   32, 32,                       /* XY origin relative to container TopLeft */
  87.   NULL,                 /* font pointer or NULL for default */
  88.   "   Click For Startup List ", /* pointer to text */
  89.   NULL                  /* next IntuiText structure */
  90. };
  91.  
  92. struct TagItem win_tags[] =     /* Window Tags  */
  93.  
  94. {
  95.   WA_Left,        MY_WIN_LEFT,
  96.   WA_Top,         MY_WIN_TOP,
  97.   WA_Width,       MY_WIN_WIDTH,
  98.   WA_Height,      MY_WIN_HEIGHT,
  99. /*  WA_DragBar,     TRUE,*/
  100.   WA_RMBTrap,     TRUE,
  101. /*  WA_CloseGadget, TRUE,*/
  102.   WA_Title,       (ULONG) " PickStartup by Bill Pierpont 1993",
  103.   WA_Activate,    TRUE,
  104.   WA_IDCMP,       IDCMP_MOUSEBUTTONS | IDCMP_CLOSEWINDOW | IDCMP_MOUSEBUTTONS | IDCMP_RAWKEY,
  105.   TAG_DONE,       NULL,
  106. };
  107. ///
  108. /* Protos */
  109. ///
  110. void ExecuteFileName(VOID);
  111. void ExecuteF1_FileName(VOID);
  112. void GetStringArg(int, int, TEXT *arg[]);
  113. VOID GetOptions (int argc, TEXT *argv[]);
  114. APTR AllocAslRequest (ULONG, struct TagItem *);
  115. VOID FreeAslRequest (APTR request);
  116. int CloseUpDevice (VOID);
  117. VOID PrintHelp(VOID);
  118. VOID GetFileName (VOID);
  119. VOID Handle_Events (struct Window *);
  120. BOOL AddPart (UBYTE * dirname, UBYTE * filename, unsigned long size);
  121. BOOL IsKeyDn (LONG);
  122.  
  123. ///
  124. /***********************************************************************
  125. *                               Globals                                *
  126. ************************************************************************/
  127. ///
  128. LONG KeyToCk = 0x63;
  129. LONG F1_Key = 0x50;
  130. LONG oslibversion = 37;
  131. ULONG LoopCount = 50000;
  132. USHORT code = NULL;
  133.  
  134. BOOL NoWin = FALSE; 
  135. BOOL Continue = TRUE;
  136. BOOL Cancelled = FALSE;
  137. BOOL Check_F1 = FALSE;
  138.  
  139. TEXT Default_Buffer[MAXPATH] = "";
  140. TEXT WorkBuf[MAXPATH] = "";
  141. TEXT F1_Buffer[MAXPATH] = "";
  142. TEXT FilePath[MAXPATH] = "s:special-startups";  /* Buffer For File request pathname    */
  143. TEXT FilePattern[MAXPATH] = "start-#?";      
  144.  
  145.  
  146. extern struct Library *IntuitionBase;
  147. extern struct Library *AslBase;
  148.  
  149. int count = 0;
  150. ///
  151.  
  152. /***********************************************************************
  153. *                            main                                      *
  154. ***********************************************************************/
  155.  
  156. int 
  157. main(int argc, TEXT *argv[])
  158. {
  159. ///
  160.  struct Window *win;  /// get options if any
  161.   if (argc > 0)
  162.     {GetOptions (argc, argv);}
  163.  
  164. if (!Continue)      /// if we found the help option quit here 
  165.     { return (0); }
  166.   else
  167.     { Continue = FALSE; }  /// reset switch                       
  168.  
  169. if (IsKeyDn(KeyToCk))
  170.   {
  171.        GetFileName ();
  172.        if (Cancelled==TRUE)  /// User Selected cancel duuh
  173.            { return(0);}
  174.           else   
  175.            { return(10); }  /// User selected File exit and kill Cli
  176.    }
  177. if (Check_F1)  // If F1 Option used do this
  178.       {  
  179.          KeyToCk = 0x50;   // 50 hex is Key Code for F1_Key         
  180.       
  181.       if (IsKeyDn(KeyToCk))
  182.               {    ExecuteF1_FileName();               /// yep its down
  183.                        if (Cancelled)                  /// Close if Cancelled Selected 
  184.                          {  return (0);}               /// and quit but don't Kill current Startup
  185.                        else
  186.                           { return (10);}       
  187.                  }
  188.               }
  189. if(NoWin)              
  190.  { return(0);}
  191. else
  192.       {
  193.         win = OpenWindowTagList (NULL, win_tags); /// open the window and print 
  194.               if (win == NULL)                          /// and print some text      
  195.                       { printf ("Window Failed to Open"); }
  196.               else
  197.                       { PrintIText (win->RPort, &IText1, 0, 0);
  198.                         Handle_Events (win);
  199.                         CloseWindow (win);                 /// you can close that window now  
  200.                        }
  201.  
  202.  /// After calling Handle_Events the 
  203.  ///Continue = code MENUDOWN or MOUSEBUTTONS
  204.  
  205.    if (code)                                  /// If window clicked code is set
  206.         {      ExecuteFileName();             /// If not set window timed out
  207.               if (Cancelled)                  /// Close if Cancelled Selected 
  208.                 {  return (0);}                /// and quit but don't Kill current Startup
  209.               else
  210.                 { return (10);}            /// job done quit and kill startup-sequence 
  211.         }
  212.       }
  213.    return (0);
  214. ///
  215. }
  216.  
  217. /***************************************************************************
  218. GetFileName()
  219.  
  220. Calls ASLreq.
  221. Get the users input.
  222. Then execute the selected script.
  223. ****************************************************************************/
  224.  
  225. void 
  226. GetFileName ()
  227. {
  228. ///
  229.   struct FileRequester *fr;
  230.   TEXT buffer[MAXPATH];
  231.  
  232.   if (AslBase = OpenLibrary ("asl.library", 37L))
  233.     {
  234.       if (fr = (struct FileRequester *) AllocAslRequestTags (ASL_FileRequest,
  235.  
  236.                         ASL_Hail, (ULONG) "Pick Startup File",
  237.                         ASL_Height, 200,
  238.                         ASL_Width,  220,
  239.                         ASL_LeftEdge, 0,
  240.                         ASL_TopEdge, 0,
  241.                         ASL_OKText, (ULONG) "OK",
  242.                         ASL_CancelText, (ULONG) "Cancel",
  243.                         ASL_Pattern, (TEXT *) &FilePattern,
  244.                         ASL_FuncFlags, FILF_PATGAD,
  245.                         ASL_Dir, (TEXT *) &FilePath,
  246.                         TAG_DONE))
  247.         {
  248.           if (AslRequest (fr, NULL))              /* This Call Opens the Requester*/
  249.             {
  250.               strcpy (buffer, "execute ");        /* Build PathName */
  251.               strcat (buffer, fr->rf_Dir);      
  252.               AddPart (buffer, fr->rf_File, sizeof (buffer) 
  253.                      - strlen (buffer));
  254.  
  255.               if(strncmp(fr->rf_File, "",1))    /*if not a null string execute it */
  256.               {Execute ((STRPTR) &buffer, NULL, NULL);}
  257.  
  258.             }
  259.           else
  260.             {
  261.               Cancelled = TRUE;
  262.             }
  263.         }       /* end if */
  264.  
  265.  
  266.       FreeAslRequest (fr);
  267.       CloseLibrary (AslBase);
  268.  
  269.     }
  270.   else
  271.     {
  272.       printf ("You Need WorkBench Version 2.04 to run this Program");
  273.     }
  274. ///
  275. }
  276.  
  277. /***********************************************************************
  278. Handle_Events()
  279.  
  280. Does what its name implies
  281. until LoopCount == 0 or user hits a mouse botton
  282. LoopCount can be changed by command line option.
  283.  
  284. I know busyloop ......badboy but becaues of the nature of the program
  285. since it isn't multitasking at this point it dosn't make any difference.
  286. Someday I hope to learn how to use Timer Device.
  287. ************************************************************************/
  288.  
  289. void 
  290. Handle_Events (struct Window *win)
  291. {
  292. ///
  293.   
  294.   ULONG class;
  295.   BOOL Done = FALSE;
  296.   struct IntuiMessage *message;
  297.   register long windowsig = 0L;
  298.   register struct MsgPort *Iport = NULL;
  299.   Iport = win->UserPort;
  300.   windowsig = 1L << Iport->mp_SigBit;
  301.      
  302.   while (!Done)
  303.     {
  304.       count++;
  305.       if (count > LoopCount)
  306.         Done = TRUE;
  307.  
  308.       while ((!Done) &&
  309.              (message = (struct IntuiMessage *) GetMsg (win->UserPort)))
  310.         {
  311.  
  312.           class = message->Class;
  313.           code = message->Code;
  314.           ReplyMsg ((struct Message *) message);
  315.  
  316.           if (class == IDCMP_MOUSEBUTTONS)
  317.             {
  318.               Done = TRUE;
  319.               Continue = TRUE;
  320.             }
  321.             else 
  322.             {
  323.               code = NULL;  /// clear code so main() does not 
  324.                             ///open ASL when we return
  325.             }
  326.           }
  327.        }
  328.   }
  329. /****************************************************************************
  330. GetOptions()
  331.  
  332. Sets up options recieved from the command line
  333.  Loop thought the argv array looking for strings that match KeyWords. 
  334.  If one is found then get and seperate the KeyWord from the rest of the 
  335.  string to get parameter the user entered. 
  336. *****************************************************************************/
  337. VOID 
  338. GetOptions (int argc, TEXT *argv[])
  339. {
  340. ///
  341.   int  length;
  342.   int count;
  343.   int temphexa;
  344.    
  345.    for (count = 1; count < argc; count++)
  346.     {    length=stclen(argv[count]);
  347.                                     
  348.       if(!strncmp(argv[count], "?",1))
  349.           {
  350.               PrintHelp();
  351.               Continue = FALSE;
  352.            }
  353.       if(!strncmp(argv[count], "NOWIN",5))
  354.           {
  355.               NoWin = TRUE;
  356.             ///  Continue = FALSE;
  357.            }
  358.  
  359.         if(!strncmp(argv[count],"FILTER=",7))
  360.              {        
  361.                   GetStringArg(8,length,&argv[count]);
  362.                   strcpy (FilePattern, WorkBuf);  
  363.              }
  364.         if(!strnicmp(argv[count], "KEY=",4))
  365.              {  
  366.                   GetStringArg(5,length,&argv[count]);
  367.                   stch_i(WorkBuf,&temphexa); /* Grrr, why isn't it like atoi?! */
  368.                   KeyToCk = temphexa ? (UWORD)temphexa : 0x63;
  369.               } 
  370.         if(!strncmp(argv[count],"RMB=",4))
  371.              {        
  372.                   GetStringArg(5,length,&argv[count]);
  373.                   if(length >4)        /* if  4 we have a string */
  374.                   {
  375.                     strcpy (Default_Buffer, "execute "); /* set up command else we use the default */
  376.                     strcat (Default_Buffer, WorkBuf);
  377.                   }  
  378.              }
  379.          if(!strncmp(argv[count],"F1=",3))
  380.              {        
  381.                 GetStringArg(4,length,&argv[count]);
  382.                 
  383.                 if(length >3)             // if  3 we have a string */
  384.                   {
  385.                     strcpy (F1_Buffer, "execute "); // set up command else we use the default */
  386.                     strcat (F1_Buffer, WorkBuf);
  387.                     Check_F1 = TRUE;
  388.                   }  
  389.              }
  390.  
  391.        if(!strncmp(argv[count], "DELAY=",6))
  392.              {  
  393.                       GetStringArg(7,length,&argv[count]);  
  394.                   if((LoopCount = strtoul(WorkBuf,NULL,10)*10000) == 0)
  395.                      {LoopCount = 5000;} 
  396.              } 
  397.        if(!strncmp(argv[count],"DIR=",4))
  398.              {        
  399.                   GetStringArg(5,length,&argv[count]);
  400.                     if(length > 4)
  401.                     {
  402.                       strcpy (FilePath, WorkBuf);
  403.                      }  
  404.               }
  405.                                       
  406.     }
  407. ///
  408. }
  409.  
  410. /****************************************************************
  411. * get the substring of the argument                             *
  412. * I really just wrote this routine to practice passing arguments*
  413. * call GetStringArg(p,l,argv)                               
  414. * p = int = to the length of the keyword+1 e.g "DIR=" is 5 
  415. * l = length of argv string (already calced.
  416. * argv = address of argv[count] string
  417. *****************************************************************/
  418.  
  419. void GetStringArg(int ParameterLength,int length,TEXT *argv[])
  420. {
  421.  ///
  422.   struct EasyStruct CommandErrorHelp =
  423.    {
  424.       sizeof(struct EasyStruct),
  425.       0,
  426.       "HELLO, You Need Help with PickStartup2",
  427.       "You have an Error in your command line Option for \n"
  428.       "%s\n"
  429.       "Do Not put a space between the Keyword and your option.\n\n"
  430.       "I will use the default value for now. ",
  431.       "OK|Show Me How",
  432. };
  433.  
  434.    
  435.        if(ParameterLength-1 == length)
  436.               { 
  437.             if(!EasyRequestArgs(NULL,&CommandErrorHelp,NULL,argv))        /* if show me how selected printHelp */
  438.                       {PrintHelp();}
  439.               }
  440.                else
  441.                { strmid(*argv,WorkBuf,ParameterLength,length);}    /* Gets the SUbstring and puts it in WorkBuf */
  442. ///
  443. }
  444. /**************************************************************************
  445. PrintHelp()
  446.  
  447. Calls EasyRequest to display some help. 
  448. Like you couldn't tell this.
  449. ***************************************************************************/
  450. void PrintHelp()
  451. {
  452.  if(!EasyRequest(NULL,&MyHelp,NULL,"(var)",2))
  453.        EasyRequest(NULL,&SomeKeyCodesHelp,NULL,"(var)",2);
  454. }
  455. ///
  456. /*************************************************************************
  457. IsKeyDn()
  458.  
  459. /* This Section of code supplied by J.Luk. */
  460.  
  461. Keyboard.device checking if a certain key is down
  462. ARGS: UWORD KeyToCk -- Raw Key Matrix code, see RKM:Libs p707(1.3),828(2.04)
  463. RESULT: BOOL of whether or not the key is down!  (sheesh)
  464. **************************************************************************/
  465.  
  466. BOOL IsKeyDn(KeyToCk)
  467. LONG KeyToCk;
  468. {
  469.    struct IOStdReq *keyRequest;
  470.    struct MsgPort *keyPort;
  471.    UBYTE *keyMatrix;
  472.  
  473.    BOOL RetFlg = FALSE;
  474.    
  475.    if (keyPort=CreatePort(NULL,NULL) )
  476.    {
  477.       if (keyRequest=(struct IOStdReq *)CreateExtIO (keyPort, sizeof (struct IOStdReq)))
  478.       {
  479.          if (!OpenDevice("keyboard.device",NULL,(struct IORequest *) keyRequest, NULL) )
  480.          {
  481.             if (keyMatrix=AllocMem(MATRIX_SIZE, MEMF_PUBLIC | MEMF_CLEAR) )
  482.             {
  483.                keyRequest->io_Command=KBD_READMATRIX;
  484.                keyRequest->io_Data=(APTR)keyMatrix;
  485.                keyRequest->io_Length=13;
  486.                
  487.                DoIO ( (struct IORequest *) keyRequest);
  488.                                                                                                 
  489.                /* Why couldn't the RKM just say this?!!!! */
  490.                /* No Shit ! */
  491.  
  492.                if (keyMatrix[KeyToCk/8] & (1L<<(KeyToCk%8))) RetFlg = TRUE;
  493.             
  494.                /* Access the byte of the key matrix, and test to see if */
  495.                /* bit KeyToCk%8 (the remainder) is set */
  496.  
  497.                FreeMem (keyMatrix, MATRIX_SIZE);
  498.             }
  499.             CloseDevice ( (struct IORequest *) keyRequest);
  500.          }
  501.          DeleteExtIO ( (struct IORequest *) keyRequest);
  502.       }      DeletePort (keyPort);
  503.    }
  504.    return (RetFlg);
  505. }
  506.  
  507.  
  508. void ExecuteFileName()
  509. {
  510.  
  511.  if(code == MENUDOWN)  /// if RMB do the default command line file only option 
  512.      {
  513.         if(strcmp(Default_Buffer,"")) /// setup up the file name from the commandline to execute 
  514.           { Execute ((STRPTR) &Default_Buffer, NULL, NULL); }
  515.          else 
  516.            { GetFileName ();}/* RMB file name entered wrong, call ASL and get one */
  517.         }   
  518.    else
  519.      { 
  520.       GetFileName(); } 
  521. }
  522. void ExecuteF1_FileName()
  523. {
  524.      
  525.  if(Check_F1)  /// if RMB do the default command line file only option 
  526.      {
  527.  
  528.         if(strcmp(F1_Buffer,"")) /// setup up the file name from the commandline to execute 
  529.           { Execute ((STRPTR) &F1_Buffer, NULL, NULL); }
  530.          else 
  531.            { GetFileName ();}/* F1 file name entered wrong, call ASL and get one */
  532.         }   
  533.    else
  534.      { GetFileName(); } 
  535. }